// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_DATE_H_
#define V8_DATE_H_

#include "src/base/timezone-cache.h"
#include "src/globals.h"
#include "src/objects/smi.h"

namespace v8 {
namespace internal {

    class V8_EXPORT_PRIVATE DateCache {
    public:
        static const int kMsPerMin = 60 * 1000;
        static const int kSecPerDay = 24 * 60 * 60;
        static const int64_t kMsPerDay = kSecPerDay * 1000;
        static const int64_t kMsPerMonth = kMsPerDay * 30;

        // The largest time that can be passed to OS date-time library functions.
        static const int kMaxEpochTimeInSec = kMaxInt;
        static const int64_t kMaxEpochTimeInMs = static_cast<int64_t>(kMaxInt) * 1000;

        // The largest time that can be stored in JSDate.
        static const int64_t kMaxTimeInMs = static_cast<int64_t>(864000000) * 10000000;

        // Conservative upper bound on time that can be stored in JSDate
        // before UTC conversion.
        static const int64_t kMaxTimeBeforeUTCInMs = kMaxTimeInMs + kMsPerMonth;

        // Sentinel that denotes an invalid local offset.
        static const int kInvalidLocalOffsetInMs = kMaxInt;
        // Sentinel that denotes an invalid cache stamp.
        // It is an invariant of DateCache that cache stamp is non-negative.
        static const int kInvalidStamp = -1;

        DateCache();

        virtual ~DateCache()
        {
            delete tz_cache_;
            tz_cache_ = nullptr;
        }

        // Clears cached timezone information and increments the cache stamp.
        void ResetDateCache(
            base::TimezoneCache::TimeZoneDetection time_zone_detection);

        // Computes floor(time_ms / kMsPerDay).
        static int DaysFromTime(int64_t time_ms)
        {
            if (time_ms < 0)
                time_ms -= (kMsPerDay - 1);
            return static_cast<int>(time_ms / kMsPerDay);
        }

        // Computes modulo(time_ms, kMsPerDay) given that
        // days = floor(time_ms / kMsPerDay).
        static int TimeInDay(int64_t time_ms, int days)
        {
            return static_cast<int>(time_ms - days * kMsPerDay);
        }

        // ECMA 262 - ES#sec-timeclip TimeClip (time)
        static double TimeClip(double time);

        // Given the number of days since the epoch, computes the weekday.
        // ECMA 262 - 15.9.1.6.
        int Weekday(int days)
        {
            int result = (days + 4) % 7;
            return result >= 0 ? result : result + 7;
        }

        bool IsLeap(int year)
        {
            return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
        }

        // ECMA 262 - ES#sec-local-time-zone-adjustment
        int LocalOffsetInMs(int64_t time, bool is_utc)
        {
            return GetLocalOffsetFromOS(time, is_utc);
        }

        const char* LocalTimezone(int64_t time_ms)
        {
            if (time_ms < 0 || time_ms > kMaxEpochTimeInMs) {
                time_ms = EquivalentTime(time_ms);
            }
            bool is_dst = DaylightSavingsOffsetInMs(time_ms) != 0;
            const char** name = is_dst ? &dst_tz_name_ : &tz_name_;
            if (*name == nullptr) {
                *name = tz_cache_->LocalTimezone(static_cast<double>(time_ms));
            }
            return *name;
        }

        // ECMA 262 - 15.9.5.26
        int TimezoneOffset(int64_t time_ms)
        {
            int64_t local_ms = ToLocal(time_ms);
            return static_cast<int>((time_ms - local_ms) / kMsPerMin);
        }

        // ECMA 262 - ES#sec-localtime-t
        // LocalTime(t) = t + LocalTZA(t, true)
        int64_t ToLocal(int64_t time_ms)
        {
            return time_ms + LocalOffsetInMs(time_ms, true);
        }

        // ECMA 262 - ES#sec-utc-t
        // UTC(t) = t - LocalTZA(t, false)
        int64_t ToUTC(int64_t time_ms)
        {
            return time_ms - LocalOffsetInMs(time_ms, false);
        }

        // Computes a time equivalent to the given time according
        // to ECMA 262 - 15.9.1.9.
        // The issue here is that some library calls don't work right for dates
        // that cannot be represented using a non-negative signed 32 bit integer
        // (measured in whole seconds based on the 1970 epoch).
        // We solve this by mapping the time to a year with same leap-year-ness
        // and same starting day for the year. The ECMAscript specification says
        // we must do this, but for compatibility with other browsers, we use
        // the actual year if it is in the range 1970..2037
        int64_t EquivalentTime(int64_t time_ms)
        {
            int days = DaysFromTime(time_ms);
            int time_within_day_ms = static_cast<int>(time_ms - days * kMsPerDay);
            int year, month, day;
            YearMonthDayFromDays(days, &year, &month, &day);
            int new_days = DaysFromYearMonth(EquivalentYear(year), month) + day - 1;
            return static_cast<int64_t>(new_days) * kMsPerDay + time_within_day_ms;
        }

        // Returns an equivalent year in the range [2008-2035] matching
        // - leap year,
        // - week day of first day.
        // ECMA 262 - 15.9.1.9.
        int EquivalentYear(int year)
        {
            int week_day = Weekday(DaysFromYearMonth(year, 0));
            int recent_year = (IsLeap(year) ? 1956 : 1967) + (week_day * 12) % 28;
            // Find the year in the range 2008..2037 that is equivalent mod 28.
            // Add 3*28 to give a positive argument to the modulus operator.
            return 2008 + (recent_year + 3 * 28 - 2008) % 28;
        }

        // Given the number of days since the epoch, computes
        // the corresponding year, month, and day.
        void YearMonthDayFromDays(int days, int* year, int* month, int* day);

        // Computes the number of days since the epoch for
        // the first day of the given month in the given year.
        int DaysFromYearMonth(int year, int month);

        // Breaks down the time value.
        void BreakDownTime(int64_t time_ms, int* year, int* month, int* day,
            int* weekday, int* hour, int* min, int* sec, int* ms);

        // Cache stamp is used for invalidating caches in JSDate.
        // We increment the stamp each time when the timezone information changes.
        // JSDate objects perform stamp check and invalidate their caches if
        // their saved stamp is not equal to the current stamp.
        Smi stamp() { return stamp_; }
        void* stamp_address() { return &stamp_; }

        // These functions are virtual so that we can override them when testing.
        virtual int GetDaylightSavingsOffsetFromOS(int64_t time_sec)
        {
            double time_ms = static_cast<double>(time_sec * 1000);
            return static_cast<int>(tz_cache_->DaylightSavingsOffset(time_ms));
        }

        virtual int GetLocalOffsetFromOS(int64_t time_ms, bool is_utc);

    private:
        // The implementation relies on the fact that no time zones have
        // more than one daylight savings offset change per 19 days.
        // In Egypt in 2010 they decided to suspend DST during Ramadan. This
        // led to a short interval where DST is in effect from September 10 to
        // September 30.
        static const int kDefaultDSTDeltaInSec = 19 * kSecPerDay;

        // Size of the Daylight Savings Time cache.
        static const int kDSTSize = 32;

        // Daylight Savings Time segment stores a segment of time where
        // daylight savings offset does not change.
        struct DST {
            int start_sec;
            int end_sec;
            int offset_ms;
            int last_used;
        };

        // Computes the daylight savings offset for the given time.
        // ECMA 262 - 15.9.1.8
        int DaylightSavingsOffsetInMs(int64_t time_ms);

        // Sets the before_ and the after_ segments from the DST cache such that
        // the before_ segment starts earlier than the given time and
        // the after_ segment start later than the given time.
        // Both segments might be invalid.
        // The last_used counters of the before_ and after_ are updated.
        void ProbeDST(int time_sec);

        // Finds the least recently used segment from the DST cache that is not
        // equal to the given 'skip' segment.
        DST* LeastRecentlyUsedDST(DST* skip);

        // Extends the after_ segment with the given point or resets it
        // if it starts later than the given time + kDefaultDSTDeltaInSec.
        inline void ExtendTheAfterSegment(int time_sec, int offset_ms);

        // Makes the given segment invalid.
        inline void ClearSegment(DST* segment);

        bool InvalidSegment(DST* segment)
        {
            return segment->start_sec > segment->end_sec;
        }

        Smi stamp_;

        // Daylight Saving Time cache.
        DST dst_[kDSTSize];
        int dst_usage_counter_;
        DST* before_;
        DST* after_;

        int local_offset_ms_;

        // Year/Month/Day cache.
        bool ymd_valid_;
        int ymd_days_;
        int ymd_year_;
        int ymd_month_;
        int ymd_day_;

        // Timezone name cache
        const char* tz_name_;
        const char* dst_tz_name_;

        base::TimezoneCache* tz_cache_;
    };

} // namespace internal
} // namespace v8

#endif // V8_DATE_H_
